home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 72 / IOPROG_72.ISO / soft / Codice / CRobots / Codice Robot anni precedenti / CR1-SRC.ZIP / CASIMIRO.R < prev    next >
Encoding:
Text File  |  1991-12-03  |  5.3 KB  |  246 lines
  1. /* Nome del Robot : " Casimiro "  (versione 37-6820) */
  2. /* Autore         : Luca Masi ( Mc4970 alias "LuM" ) */
  3. /* Realizzazione  : 16 & 17 giugno 1991 a Roma       */
  4. /* Test & Debug   : 18 giugno - 30 novembre 1991     */
  5. /* Ringraziamenti : Andrea Masi, i386/25 e Mc-Link   */
  6.  
  7. int    angolo;                            /* Numero dell' angolo attuale */
  8. int    a1x, a1y, a2x, a2y, a3x, a3y, a4x, a4y;   /* Coordinate dei 4 angoli     */
  9. int    grado, g1;                          /* Grado attuale per lo scan   */
  10. int    range;                             /* Lontananza dell' avversario */
  11. int    danno;                             /* Danni subiti fino ad ora    */
  12. int    posx, posy;                         /* Posizione iniziale Casimiro */
  13. int    conta;
  14.  
  15. main()
  16. {
  17.     a1x = 0;       
  18.     a1y = 0;              /*         Inizializza         */
  19.     a2x = 0;       
  20.     a2y = 999;            /*        le coordinate        */
  21.     a4x = 999;     
  22.     a4y = 999;            /*         dei 4 angoli        */
  23.     a3x = 999;     
  24.     a3y = 0;              /*          principali         */
  25.  
  26.     dove();
  27.     if (angolo == 0) 
  28.         arriva (a1x, a1y, inclina(a1x, a1y, posx, posy));
  29.     else
  30.      {
  31.         if (angolo == 1) 
  32.             arriva (a2x, a2y, inclina(a2x, a2y, posx, posy));
  33.         else
  34.          {
  35.             if (angolo == 2) 
  36.                 arriva (a3x, a3y, inclina(a3x, a3y, posx, posy));
  37.             else 
  38.                 arriva (a4x, a4y, inclina(a4x, a4y, posx, posy));
  39.         }
  40.     }
  41.  
  42.     conta = 0;
  43.     danno = damage();
  44.  
  45.     while (conta < 266) {
  46.         if (angolo > 1) 
  47.             grado = angolo * 90 - 1;
  48.         else 
  49.             grado = angolo * 270 + 89;
  50.         g1 = grado;
  51.         while (danno == damage() && conta < 266) {
  52.             range = scan(g1, 4);
  53.             while (range > 40 && range < 850 && danno == damage()) {
  54.                 cannon(g1, range);
  55.                 range = scan(g1, 4);
  56.             }
  57.             g1 -= 8;
  58.             if (grado - g1 > 88) {
  59.                 g1 = grado;
  60.                 conta += 1;
  61.             }
  62.         }
  63.         cambia_angolo();
  64.         danno = damage();
  65.     }
  66.  
  67.     grado = g1;
  68.     g1 = 0;
  69.     while (1) {
  70.         while ((range = scan(grado, 4)) > 0) {
  71.             drive(grado, 0);
  72.             if (range > 730) 
  73.                 drive(grado, 100);
  74.             else if (range > 40) 
  75.                 cannon(grado, range);
  76.             grado -= 12;
  77.             check();
  78.         }
  79.         grado += 8;
  80.     }
  81. }
  82.  
  83.  
  84. check()                                /* Gestione movimenti II robot */
  85. {
  86.     int    somma, verso;
  87.     if (danno != damage()) {
  88.         danno = damage();
  89.         conta = 0;
  90.         if (g1 == 0) {
  91.             g1 = 1;
  92.             posy = loc_y();
  93.             if (posy > 512) {
  94.                 somma = -100;
  95.                 verso = 270;
  96.             } else
  97.              {
  98.                 somma = 100;
  99.                 verso = 90;
  100.             }
  101.             drive(verso, 100);
  102.             while (posy + somma < loc_y() && conta++ < 100)
  103.                 ;
  104.             drive(verso, 0);
  105.         } else
  106.          {
  107.             g1 = 0;
  108.             posx = loc_x();
  109.             if (posx > 512) {
  110.                 somma = -100;
  111.                 verso = 180;
  112.             } else
  113.              {
  114.                 somma = 100;
  115.                 verso = 0;
  116.             }
  117.             drive(verso, 100);
  118.             while (posx + somma < loc_x() && conta++ < 100)
  119.                 ;
  120.             drive(verso, 0);
  121.         }
  122.     }
  123. }
  124.  
  125.  
  126. distanza(x1, y1, x2, y2)                  /* La distanza tra due punti   */
  127. int    x1, y1, x2, y2;
  128. {
  129.     int    x, y;
  130.     x = x1 - x2;
  131.     y = y1 - y2;
  132.     return(sqrt((x * x) + (y * y)));
  133. }
  134.  
  135.  
  136. arriva(x, y, dir)                        /* Si sposta ad una locazione  */
  137. int    x, y, dir;
  138. {
  139.     drive(dir, 100);
  140.     while (distanza(loc_x(), loc_y(), x, y) > 100 && speed() > 0)
  141.         ;
  142.     drive(dir, 20);
  143.     while (distanza(loc_x(), loc_y(), x, y) > 10 && speed() > 0)
  144.         ;
  145.     drive(dir, 0);
  146. }
  147.  
  148.  
  149. inclina(a, b, c, d)                       /* Angolo per lo spostamento   */
  150. int    a, b, c, d;
  151. {
  152.     int    calcola, x, y;
  153.     x = c - a;
  154.     y = d - b;
  155.     if (x == 0) {
  156.         if (b > posy) 
  157.             calcola = 90;
  158.         else 
  159.             calcola = 270;
  160.     } else
  161.      {
  162.         if (b < posy) {
  163.             if (a > posx) 
  164.                 calcola = 360 + atan((100000 * y) / x);
  165.             else 
  166.                 calcola = 180 + atan((100000 * y) / x);
  167.         } else
  168.          {
  169.             if (a > posx) 
  170.                 calcola = atan((100000 * y ) / x);
  171.             else 
  172.                 calcola = 180 + atan((100000 * y) / x);
  173.         }
  174.     }
  175.     return(calcola);
  176. }
  177.  
  178.  
  179. dove()                                 /* In quale angol si trova ?!? */
  180. {
  181.     posx = loc_x(); 
  182.     posy = loc_y();
  183.     if (posx > 500) 
  184.         angolo = 2;
  185.     else 
  186.         angolo = 0;
  187.     if (posy > 500) 
  188.         angolo += 1;
  189. }
  190.  
  191.  
  192. cambia_angolo()                        /* Arriva ad un nuovo angolo   */
  193. {
  194.     if (angolo == 0) {
  195.         if (scan(90, 3) == 0) 
  196.             arriva(a2x, a2y, inclina(a2x, a2y, loc_x(), loc_y()));
  197.         else
  198.          {
  199.             if (scan(0, 3) == 0) 
  200.                 arriva(a3x, a3y, inclina(a3x, a3y, loc_x(), loc_y()));
  201.             else 
  202.                 arriva(a4x, a4y, inclina(a4x, a4y, loc_x(), loc_y()));
  203.         }
  204.     } else
  205.      {
  206.         if (angolo == 1) {
  207.             if (scan(0, 3) == 0) 
  208.                 arriva(a4x, a4y, inclina(a4x, a4y, loc_x(), loc_y()));
  209.             else
  210.              {
  211.                 if (scan(270, 3) == 0) 
  212.                     arriva(a1x, a1y, inclina(a1x, a1y, loc_x(), loc_y()));
  213.                 else 
  214.                     arriva(a3x, a3y, inclina(a3x, a3y, loc_x(), loc_y()));
  215.             }
  216.         } else
  217.          {
  218.             if (angolo == 3) {
  219.                 if (scan(270, 3) == 0) 
  220.                     arriva(a3x, a3y, inclina(a3x, a3y, loc_x(), loc_y()));
  221.                 else
  222.                  {
  223.                     if (scan(180, 3) == 0) 
  224.                         arriva(a2x, a2y, inclina(a2x, a2y, loc_x(), loc_y()));
  225.                     else 
  226.                         arriva(a1x, a1y, inclina(a1x, a1y, loc_x(), loc_y()));
  227.                 }
  228.             } else
  229.              {
  230.                 if (scan(180, 3) == 0) 
  231.                     arriva(a1x, a1y, inclina(a1x, a1y, loc_x(), loc_y()));
  232.                 else
  233.                  {
  234.                     if (scan(90, 3) == 0) 
  235.                         arriva(a4x, a4y, inclina(a4x, a4y, loc_x(), loc_y()));
  236.                     else 
  237.                         arriva(a2x, a2y, inclina(a2x, a2y, loc_x(), loc_y()));
  238.                 }
  239.             }
  240.         }
  241.     }
  242.     dove();
  243. }
  244.  
  245.  
  246.